package com.ffggffgfv.backend.service.impl;

import com.ffggffgfv.backend.dto.CartDisplayDTO;
import com.ffggffgfv.backend.dto.CartItemDTO;
import com.ffggffgfv.backend.entity.Cart;
import com.ffggffgfv.backend.entity.Product;
import com.ffggffgfv.backend.mapper.CartMapper;
import com.ffggffgfv.backend.mapper.ProductMapper;
import com.ffggffgfv.backend.service.CartService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Logger;

/**
 * 购物车服务实现类
 */
@Service
public class CartServiceImpl implements CartService {

    private static final Logger logger = Logger.getLogger(CartServiceImpl.class.getName());

    @Autowired
    private CartMapper cartMapper;

    @Autowired
    private ProductMapper productMapper;

    /**
     * 获取用户购物车列表
     *
     * @param userId 用户ID
     * @return 购物车项展示列表
     */
    @Override
    public List<CartDisplayDTO> getCartList(Long userId) {
        List<Cart> cartItems = cartMapper.selectByUserId(userId);
        List<CartDisplayDTO> result = new ArrayList<>();

        for (Cart cart : cartItems) {
            // 根据商品ID查询商品信息
            Product product = productMapper.selectById(cart.getProductId());
            if (product == null || product.getStatus() == 0) {
                // 如果商品已下架或删除，则跳过
                logger.warning("商品不存在或已下架，购物车ID: " + cart.getId() + ", 商品ID: " + cart.getProductId());
                continue;
            }

            CartDisplayDTO dto = new CartDisplayDTO();
            dto.setId(cart.getId());
            dto.setProductId(product.getId());
            dto.setProductName(product.getName());
            dto.setProductImage(product.getMainImageUrl());
            dto.setPrice(product.getPrice());
            dto.setQuantity(cart.getQuantity());
            dto.setSelected(cart.getSelected() == 1);
            // 计算小计金额
            BigDecimal totalPrice = product.getPrice().multiply(new BigDecimal(cart.getQuantity()));
            dto.setTotalPrice(totalPrice);

            result.add(dto);
        }

        return result;
    }

    /**
     * 添加商品到购物车
     *
     * @param userId      用户ID
     * @param cartItemDTO 购物车项信息
     * @return 添加后的购物车项
     */
    @Override
    public Cart addToCart(Long userId, CartItemDTO cartItemDTO) {
        // 参数校验
        if (cartItemDTO.getProductId() == null || cartItemDTO.getQuantity() == null || cartItemDTO.getQuantity() <= 0) {
            logger.warning("添加购物车参数不合法: " + cartItemDTO.toString());
            return null;
        }

        // 检查商品是否存在并且是上架状态
        Product product = productMapper.selectById(cartItemDTO.getProductId());
        if (product == null || product.getStatus() == 0) {
            logger.warning("商品不存在或已下架，无法添加到购物车，商品ID: " + cartItemDTO.getProductId());
            return null;
        }

        // 检查购物车中是否已有该商品
        Cart existingCart = cartMapper.selectByUserIdAndProductId(userId, cartItemDTO.getProductId());

        if (existingCart != null) {
            // 如果已存在，则更新数量
            existingCart.setQuantity(existingCart.getQuantity() + cartItemDTO.getQuantity());
            // 如果传入了选中状态，则更新选中状态
            if (cartItemDTO.getSelected() != null) {
                existingCart.setSelected(cartItemDTO.getSelected() ? 1 : 0);
            }
            existingCart.setUpdateTime(LocalDateTime.now());
            cartMapper.update(existingCart);
            return existingCart;
        } else {
            // 如果不存在，则插入新记录
            Cart cart = new Cart();
            cart.setUserId(userId);
            cart.setProductId(cartItemDTO.getProductId());
            cart.setQuantity(cartItemDTO.getQuantity());
            // 默认选中状态为1，如果传入了选中状态，则使用传入的选中状态
            cart.setSelected(cartItemDTO.getSelected() == null || cartItemDTO.getSelected() ? 1 : 0);
            cart.setCreateTime(LocalDateTime.now());
            cart.setUpdateTime(LocalDateTime.now());

            cartMapper.insert(cart);
            return cart;
        }
    }

    /**
     * 更新购物车项
     *
     * @param userId      用户ID
     * @param cartItemDTO 购物车项信息
     * @return 更新后的购物车项
     */
    @Override
    public Cart updateCart(Long userId, CartItemDTO cartItemDTO) {
        // 参数校验
        if (cartItemDTO.getProductId() == null) {
            logger.warning("更新购物车参数不合法，缺少商品ID");
            return null;
        }

        // 检查购物车中是否有该商品
        Cart cart = cartMapper.selectByUserIdAndProductId(userId, cartItemDTO.getProductId());
        if (cart == null) {
            logger.warning("购物车中不存在此商品，用户ID: " + userId + ", 商品ID: " + cartItemDTO.getProductId());
            return null;
        }

        // 更新数量和选中状态
        if (cartItemDTO.getQuantity() != null && cartItemDTO.getQuantity() > 0) {
            cart.setQuantity(cartItemDTO.getQuantity());
        }

        if (cartItemDTO.getSelected() != null) {
            cart.setSelected(cartItemDTO.getSelected() ? 1 : 0);
        }

        cart.setUpdateTime(LocalDateTime.now());
        cartMapper.update(cart);

        return cart;
    }

    /**
     * 删除购物车项
     *
     * @param userId    用户ID
     * @param productId 商品ID
     * @return 影响的行数
     */
    @Override
    public int deleteCartItem(Long userId, Long productId) {
        return cartMapper.deleteByUserIdAndProductId(userId, productId);
    }

    /**
     * 清空购物车
     *
     * @param userId 用户ID
     * @return 影响的行数
     */
    @Override
    public int clearCart(Long userId) {
        return cartMapper.deleteByUserId(userId);
    }

    /**
     * 切换购物车项的选中状态
     *
     * @param userId    用户ID
     * @param productId 商品ID
     * @param selected  选中状态
     * @return 影响的行数
     */
    @Override
    public int toggleSelected(Long userId, Long productId, Boolean selected) {
        int selectedValue = selected ? 1 : 0;
        return cartMapper.updateSelected(userId, productId, selectedValue);
    }

    /**
     * 全选/全不选
     *
     * @param userId   用户ID
     * @param selected 选中状态
     * @return 影响的行数
     */
    @Override
    public int toggleAllSelected(Long userId, Boolean selected) {
        int selectedValue = selected ? 1 : 0;
        return cartMapper.updateAllSelected(userId, selectedValue);
    }

    /**
     * 获取购物车商品数量
     *
     * @param userId 用户ID
     * @return 商品数量
     */
    @Override
    public int getCartProductCount(Long userId) {
        List<Cart> cartItems = cartMapper.selectByUserId(userId);
        int count = 0;
        for (Cart item : cartItems) {
            count += item.getQuantity();
        }
        return count;
    }

    /**
     * 获取选中的购物车项，用于结算
     *
     * @param userId 用户ID
     * @return 选中的购物车项和汇总信息
     */
    @Override
    public Map<String, Object> getSelectedCartItems(Long userId) {
        List<Cart> cartItems = cartMapper.selectByUserId(userId);
        List<CartDisplayDTO> selectedItems = new ArrayList<>();
        BigDecimal totalAmount = BigDecimal.ZERO;
        int totalQuantity = 0;

        for (Cart cart : cartItems) {
            // 只处理选中的项目
            if (cart.getSelected() != 1) {
                continue;
            }

            // 查询商品信息
            Product product = productMapper.selectById(cart.getProductId());
            if (product == null || product.getStatus() == 0) {
                // 如果商品已下架或删除，则跳过
                logger.warning("结算时发现商品不存在或已下架，购物车ID: " + cart.getId() + ", 商品ID: " + cart.getProductId());
                continue;
            }

            CartDisplayDTO dto = new CartDisplayDTO();
            dto.setId(cart.getId());
            dto.setProductId(product.getId());
            dto.setProductName(product.getName());
            dto.setProductImage(product.getMainImageUrl());
            dto.setPrice(product.getPrice());
            dto.setQuantity(cart.getQuantity());
            dto.setSelected(true);
            // 计算小计金额
            BigDecimal itemTotal = product.getPrice().multiply(new BigDecimal(cart.getQuantity()));
            dto.setTotalPrice(itemTotal);

            selectedItems.add(dto);

            // 累加总金额和总数量
            totalAmount = totalAmount.add(itemTotal);
            totalQuantity += cart.getQuantity();
        }

        // 组装返回结果
        Map<String, Object> result = new HashMap<>();
        result.put("cartItems", selectedItems);
        result.put("totalAmount", totalAmount);
        result.put("totalQuantity", totalQuantity);

        return result;
    }
}
